const { app, BrowserWindow, Menu, dialog, Tray, ipcMain } = require('electron');
const fs = require('fs').promises;
const path = require('path');
const XLSX = require('xlsx');
let tray;
// 确保目录存在
const PROCESSED_DIR = path.join(app.getPath('documents'), '考评系统导出'); // 更友好路径

async function ensureDir() {
  try {
    await fs.access(PROCESSED_DIR);
  } catch {
    await fs.mkdir(PROCESSED_DIR, { recursive: true });
  }
}

async function createWindow() {
  await ensureDir();
   const iconPath = process.platform === 'win32' ? path.join(__dirname, 'build', 'icon.ico') : path.join(__dirname, 'build', 'icon.png');
    createTray(iconPath);
    const menu = Menu.buildFromTemplate([
        {
            label: '简介',
            submenu: [
                {
                    label: '简介',
                    click() {
                        dialog.showMessageBox(mainWindow, {
                            type: 'info',
                            title: '简介',
                            message: '这是一个文件同步工具。',
                            buttons: ['确定']
                        });
                    }
                }
            ]
        },
        {
            label: '试用人员',

            submenu: [
                {
                    label: '试用人员',
                    click() {
                        dialog.showMessageBox(mainWindow, {
                            type: 'info',
                            title: '试用人员',
                            message: '粥粥粥',
                            buttons: ['确定']
                        });
                    }
                }
            ]
        }
    ])
    Menu.setApplicationMenu(menu)
    function createTray(iconPath) {
        try {
            if (tray) {
                return;
            }
            tray = new Tray(iconPath);
            tray.setToolTip('考评匹配系统Max'); // 添加这行设置悬停提示
            const contextMenu = Menu.buildFromTemplate([
                {
                    label: '显示窗口',
                    click: () => {
                        if (mainWindow) {
                            // 若窗口存在，不管是否销毁，都尝试显示
                            if (mainWindow.isDestroyed()) {
                                // 若窗口已销毁，重新创建
                                createWindow();
                            } else {
                                // 若窗口未销毁，直接显示
                                mainWindow.show();
                            }
                        } else {
                            // 若窗口不存在，重新创建
                            createWindow();
                        }
                    }
                },
                {
                    label: '退出',
                    click: () => {
                        app.isQuitting = true;
                        app.quit();
                    }
                }
            ]);
            tray.setContextMenu(contextMenu);
            tray.on('click', () => {
                if (mainWindow) {
                    // 若窗口存在，不管是否销毁，都尝试显示
                    if (mainWindow.isDestroyed()) {
                        // 若窗口已销毁，重新创建
                        createWindow();
                    } else {
                        // 若窗口未销毁，直接显示
                        mainWindow.show();
                    }
                } else {
                    // 若窗口不存在，重新创建
                    createWindow();
                }
            });
    
        } catch (error) {
            // log(`创建托盘图标时出错: ${error.message}`);
        }
    }
  const mainWindow = new BrowserWindow({
        width: 1200,
        height: 600,
        title: '系统工具',// 应用标题
        icon: iconPath,

    webPreferences: {
        nodeIntegration: true,
      preload: path.join(__dirname, 'preload.js')
    }
  });
// mainWindow.webContents.openDevTools()
  mainWindow.loadFile('index.html');
}

app.whenReady().then(createWindow);

// 👇 核心：处理上传的 Excel 文件
ipcMain.handle('process-excel', async (event, fileBuffer, filename, sid, password) => {
  try {
    // 类型检查
    if (typeof sid !== 'number' || isNaN(sid) || sid <= 0) {
      return { success: false, message: '无效的科目ID' };
    }

    if (!password) {
      return { success: false, message: '请输入密码' };
    }

    const workbook = XLSX.read(fileBuffer, { type: 'buffer' });
    const sheetNames = workbook.SheetNames;

    if (sheetNames.length < 2) {
      return { success: false, message: 'Excel 必须至少包含两个工作表' };
    }

    // Sheet 0: 考评员
    const userSheet = workbook.Sheets[sheetNames[0]];
    const userListData = XLSX.utils.sheet_to_json(userSheet);
    
    // 检查是否有分组字段
    if (userListData.length > 0 && !('分组' in userListData[0])) {
      return { success: false, message: '考评员工作表中未找到【分组】字段' };
    }
    
    // 统一为所有考评员设置密码
    userListData.forEach((user,index) => {
  // 创建新对象，先放入序号字段
  const newUser = {
    序号: index + 1,
    // 合并原用户对象的所有属性
    ...user,
    // 最后添加密码字段，确保它在最后
    密码: password
  };
  
  // 替换原数组中的对象
  userListData[index] = newUser;
    });
    
    // 创建按分组组织的考评员映射
    const userGroups = {};
    userListData.forEach(user => {
      const username = user.用户名;
      const groupId = user.分组 || '未分组'; // 如果没有分组，使用'未分组'
      
      if (username) { // 确保用户名存在
        if (!userGroups[groupId]) {
          userGroups[groupId] = [];
        }
        userGroups[groupId].push(username);
      }
    });
    
    if (Object.keys(userGroups).length === 0) {
      return { success: false, message: '未找到有效的考评员数据' };
    }

    // Sheet 1: 考生
    const candidateSheet = workbook.Sheets[sheetNames[1]];
    const candidateData = XLSX.utils.sheet_to_json(candidateSheet);
    
    // 检查是否有分组字段
    if (candidateData.length > 0 && !('分组' in candidateData[0])) {
      return { success: false, message: '考生工作表中未找到【分组】字段' };
    }
    
    // 创建按分组组织的考生映射
    const candidateGroups = {};
    candidateData.forEach(candidate => {
      const examNumber = candidate.考生准考证尾号;
      const groupId = candidate.分组 || '未分组'; // 如果没有分组，使用'未分组'
      
      if (examNumber) { // 确保准考证尾号存在
        if (!candidateGroups[groupId]) {
          candidateGroups[groupId] = [];
        }
        candidateGroups[groupId].push(examNumber);
      }
    });
    
    if (Object.keys(candidateGroups).length === 0) {
      return { success: false, message: '未找到有效的考生数据' };
    }

    // ✅ 使用前端传入的 sid，按分组匹配
    let arr = [];
    
    // 对每个分组进行匹配
    Object.keys(userGroups).forEach(groupId => {
      const groupUsers = userGroups[groupId];
      const groupCandidates = candidateGroups[groupId] || [];
      
      if (groupCandidates.length > 0) {
        // 只有在相同分组中存在考生时才进行匹配
        for (let user of groupUsers) {
          for (let cand of groupCandidates) {
            arr.push([user, cand, sid]); // 使用用户输入的 sid
          }
        }
      }
    });

    const data = arr.map((item, i) => [i + 1, ...item]);
    const header = ["序号", "考评员账号", "考生准考证尾号", "科目ID"];
    userListData.forEach(user => {
      if ('分组' in user) {
        delete user.分组;
      }
    });
    // 创建带有密码的考评员工作表副本
    // 直接修改原始工作表的数据
    const passwordUserSheet = XLSX.utils.json_to_sheet(userListData);
    // 替换原始工作表
    workbook.Sheets[sheetNames[0]] = passwordUserSheet;
     // 删除名称为'考生信息'的sheet
    const sheetIndex = workbook.SheetNames.findIndex(name => name === '考生信息');
    if (sheetIndex !== -1) {
      // 从SheetNames数组中删除
      workbook.SheetNames.splice(sheetIndex, 1);
      // 从Sheets对象中删除
      delete workbook.Sheets['考生信息'];
    }
    const newWorksheet = XLSX.utils.aoa_to_sheet([header, ...data]);
    XLSX.utils.book_append_sheet(workbook, newWorksheet, `考评员考生匹配表`);

    const outputBuffer = XLSX.write(workbook, { 
      type: 'buffer', 
      bookType: 'xlsx' 
    });

    const processedFilename = `考评匹配_${sid}_${Date.now()}.xlsx`;

    return {
      success: true,
      message: `处理完成：${Object.values(userGroups).flat().length} 名考评员数据，已统一设置密码`,
      matchCount: arr.length,
      buffer: Array.from(outputBuffer),
      defaultSaveName: processedFilename
    };

  } catch (err) {
    console.error(err);
    return { success: false, message: `处理失败：${err.message}` };
  }
});


// 👇 下载文件（用户选择路径）
ipcMain.handle('download-processed-file', async (event, bufferArray, defaultName) => {
  try {
    const { canceled, filePath } = await dialog.showSaveDialog({
      title: '保存处理后的文件',
      defaultPath: path.join(PROCESSED_DIR, defaultName),
      filters: [
        { name: 'Excel 文件', extensions: ['xlsx'] }
      ]
    });

    if (canceled || !filePath) {
      return { canceled: true };
    }

    // 写入用户选择的路径
    const buffer = Buffer.from(bufferArray);
    await fs.writeFile(filePath, buffer);

    return {
      canceled: false,
      filePath
    };
  } catch (err) {
    console.error(err);
    throw err;
  }
});